/**
 * This is a generated class and is not intended for modification.  To customize behavior
 * of this service wrapper you may modify the generated sub-class of this class - WebService.as.
 */
package services.webservice
{
import com.adobe.fiber.core.model_internal;
import com.adobe.fiber.services.wrapper.WebServiceWrapper;
import com.adobe.serializers.utility.TypeUtility;
import mx.rpc.AbstractOperation;
import mx.rpc.AsyncToken;
import mx.rpc.soap.mxml.Operation;
import mx.rpc.soap.mxml.WebService;
import valueObjects.Accidente;
import valueObjects.AgregarAccidenteResponse;
import valueObjects.AgregarHablaFacilResponse;
import valueObjects.AgregarMensajeResponse;
import valueObjects.AgregarRolCapacitacionResponse;
import valueObjects.AgregarTacsaResponse;
import valueObjects.EliminarAccidenteResponse;
import valueObjects.EliminarHablaFacilResponse;
import valueObjects.EliminarMensajeResponse;
import valueObjects.EliminarRolCapacitacionResponse;
import valueObjects.EliminarTacsaResponse;
import valueObjects.FiltroAccidente;
import valueObjects.FiltroHablaFacil;
import valueObjects.FiltroRolCapacitacion;
import valueObjects.FiltroTacsa;
import valueObjects.GetMensajesValidosResponse;
import valueObjects.HablaFacil;
import valueObjects.ListarAccidenteReproductorResponse;
import valueObjects.ListarAccidenteResponse;
import valueObjects.ListarHablaFacilResponse;
import valueObjects.ListarMensajeResponse;
import valueObjects.ListarParametroResponse;
import valueObjects.ListarRolCapacitacionReproductorResponse;
import valueObjects.ListarRolCapacitacionResponse;
import valueObjects.ListarTacsaResponse;
import valueObjects.ModificarAccidenteResponse;
import valueObjects.ModificarHablaFacilResponse;
import valueObjects.ModificarMensajeResponse;
import valueObjects.ModificarParametroResponse;
import valueObjects.ModificarRolCapacitacionResponse;
import valueObjects.ModificarTacsaResponse;
import valueObjects.ObtenerAccidenteResponse;
import valueObjects.ObtenerHablaFacilReproductorPromedioResponse;
import valueObjects.ObtenerHablaFacilReproductorResponse;
import valueObjects.ObtenerRolCapacitacionResponse;
import valueObjects.ObtenerTacsaReproductorResponse;
import valueObjects.ObtenerUsuarioResponse;
import valueObjects.ReporteHablaFacilResponse;
import valueObjects.RolCapacitacion;
import valueObjects.Tacsa;

[ExcludeClass]
internal class _Super_WebService extends com.adobe.fiber.services.wrapper.WebServiceWrapper
{
    
    // Constructor
    public function _Super_WebService()
    {
        // initialize service control
        _serviceControl = new mx.rpc.soap.mxml.WebService();
        var operations:Object = new Object();
        var operation:mx.rpc.soap.mxml.Operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerAccidente");
         operation.resultType = valueObjects.ObtenerAccidenteResponse;
        operations["obtenerAccidente"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "eliminarMensaje");
         operation.resultType = valueObjects.EliminarMensajeResponse;
        operations["eliminarMensaje"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarParametro");
         operation.resultType = valueObjects.ListarParametroResponse;
        operations["listarParametro"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "eliminarTacsa");
         operation.resultType = valueObjects.EliminarTacsaResponse;
        operations["eliminarTacsa"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarAccidente");
         operation.resultType = valueObjects.ListarAccidenteResponse;
        operations["listarAccidente"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "testConnection");
         operation.resultType = String;
        operations["testConnection"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerTacsaReproductorTest");
        operations["obtenerTacsaReproductorTest"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "reporteHablaFacil");
         operation.resultType = valueObjects.ReporteHablaFacilResponse;
        operations["reporteHablaFacil"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarTacsa");
         operation.resultType = valueObjects.ListarTacsaResponse;
        operations["listarTacsa"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarAccidenteReproductor");
         operation.resultType = valueObjects.ListarAccidenteReproductorResponse;
        operations["listarAccidenteReproductor"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarRolCapacitacionReproductor");
         operation.resultType = valueObjects.ListarRolCapacitacionReproductorResponse;
        operations["listarRolCapacitacionReproductor"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "modificarMensaje");
         operation.resultType = valueObjects.ModificarMensajeResponse;
        operations["modificarMensaje"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "agregarRolCapacitacion");
         operation.resultType = valueObjects.AgregarRolCapacitacionResponse;
        operations["agregarRolCapacitacion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarMensaje");
         operation.resultType = valueObjects.ListarMensajeResponse;
        operations["listarMensaje"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "agregarMensaje");
         operation.resultType = valueObjects.AgregarMensajeResponse;
        operations["agregarMensaje"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "eliminarHablaFacil");
         operation.resultType = valueObjects.EliminarHablaFacilResponse;
        operations["eliminarHablaFacil"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "agregarAccidente");
         operation.resultType = valueObjects.AgregarAccidenteResponse;
        operations["agregarAccidente"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "modificarHablaFacil");
         operation.resultType = valueObjects.ModificarHablaFacilResponse;
        operations["modificarHablaFacil"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "modificarAccidente");
         operation.resultType = valueObjects.ModificarAccidenteResponse;
        operations["modificarAccidente"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "agregarHablaFacil");
         operation.resultType = valueObjects.AgregarHablaFacilResponse;
        operations["agregarHablaFacil"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "eliminarRolCapacitacion");
         operation.resultType = valueObjects.EliminarRolCapacitacionResponse;
        operations["eliminarRolCapacitacion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerUsuario");
         operation.resultType = valueObjects.ObtenerUsuarioResponse;
        operations["obtenerUsuario"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerHablaFacilReproductorPromedio");
         operation.resultType = valueObjects.ObtenerHablaFacilReproductorPromedioResponse;
        operations["obtenerHablaFacilReproductorPromedio"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerTacsaReproductor");
         operation.resultType = valueObjects.ObtenerTacsaReproductorResponse;
        operations["obtenerTacsaReproductor"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "modificarRolCapacitacion");
         operation.resultType = valueObjects.ModificarRolCapacitacionResponse;
        operations["modificarRolCapacitacion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerRolCapacitacion");
         operation.resultType = valueObjects.ObtenerRolCapacitacionResponse;
        operations["obtenerRolCapacitacion"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "modificarParametro");
         operation.resultType = valueObjects.ModificarParametroResponse;
        operations["modificarParametro"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "modificarTacsa");
         operation.resultType = valueObjects.ModificarTacsaResponse;
        operations["modificarTacsa"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "eliminarAccidente");
         operation.resultType = valueObjects.EliminarAccidenteResponse;
        operations["eliminarAccidente"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "obtenerHablaFacilReproductor");
         operation.resultType = valueObjects.ObtenerHablaFacilReproductorResponse;
        operations["obtenerHablaFacilReproductor"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "getMensajesValidos");
         operation.resultType = valueObjects.GetMensajesValidosResponse;
        operations["getMensajesValidos"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "agregarTacsa");
         operation.resultType = valueObjects.AgregarTacsaResponse;
        operations["agregarTacsa"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarHablaFacil");
         operation.resultType = valueObjects.ListarHablaFacilResponse;
        operations["listarHablaFacil"] = operation;

        operation = new mx.rpc.soap.mxml.Operation(null, "listarRolCapacitacion");
         operation.resultType = valueObjects.ListarRolCapacitacionResponse;
        operations["listarRolCapacitacion"] = operation;

        _serviceControl.operations = operations;
        try
        {
            _serviceControl.convertResultHandler = com.adobe.serializers.utility.TypeUtility.convertResultHandler;
        }
        catch (e: Error)
        { /* Flex 3.4 and earlier does not support the convertResultHandler functionality. */ }


        preInitializeService();
        model_internal::initialize();
    }
    
    //init initialization routine here, child class to override
    protected function preInitializeService():void
    {


        _serviceControl.service = "WebService";
        _serviceControl.port = "WebServiceSoap";
        wsdl = "http://10.30.17.11:81/WSVIDEO/webservice.asmx?WSDL";
        model_internal::loadWSDLIfNecessary();
    }
    

    /**
      * This method is a generated wrapper used to call the 'obtenerAccidente' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerAccidente(filtroAccidente:valueObjects.FiltroAccidente) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerAccidente");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(filtroAccidente) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'eliminarMensaje' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function eliminarMensaje(id:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("eliminarMensaje");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(id) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarParametro' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarParametro() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarParametro");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'eliminarTacsa' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function eliminarTacsa(tacsa:valueObjects.Tacsa) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("eliminarTacsa");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(tacsa) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarAccidente' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarAccidente(filtroAccidente:valueObjects.FiltroAccidente) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarAccidente");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(filtroAccidente) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'testConnection' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function testConnection() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("testConnection");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'obtenerTacsaReproductorTest' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerTacsaReproductorTest() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerTacsaReproductorTest");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'reporteHablaFacil' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function reporteHablaFacil() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("reporteHablaFacil");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarTacsa' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarTacsa(filtroTacsa:valueObjects.FiltroTacsa) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarTacsa");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(filtroTacsa) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarAccidenteReproductor' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarAccidenteReproductor() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarAccidenteReproductor");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarRolCapacitacionReproductor' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarRolCapacitacionReproductor() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarRolCapacitacionReproductor");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'modificarMensaje' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function modificarMensaje(id:int, descripcion:String, fechaEmitir:String, fechaTermino:String, ciclico:Boolean, dom:Boolean, lun:Boolean, mar:Boolean, mie:Boolean, jue:Boolean, vie:Boolean, sab:Boolean, intervalo:Boolean, intervaloHoras:int, intervaloMinutos:int, vecesRepetir:int, user:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("modificarMensaje");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(id,descripcion,fechaEmitir,fechaTermino,ciclico,dom,lun,mar,mie,jue,vie,sab,intervalo,intervaloHoras,intervaloMinutos,vecesRepetir,user) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'agregarRolCapacitacion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function agregarRolCapacitacion(rolCapacitacion:valueObjects.RolCapacitacion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("agregarRolCapacitacion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(rolCapacitacion) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarMensaje' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarMensaje() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarMensaje");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'agregarMensaje' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function agregarMensaje(descripcion:String, fechaEmitir:String, fechaTermino:String, ciclico:Boolean, dom:Boolean, lun:Boolean, mar:Boolean, mie:Boolean, jue:Boolean, vie:Boolean, sab:Boolean, intervalo:Boolean, intervaloHoras:int, intervaloMinutos:int, vecesRepetir:int, user:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("agregarMensaje");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(descripcion,fechaEmitir,fechaTermino,ciclico,dom,lun,mar,mie,jue,vie,sab,intervalo,intervaloHoras,intervaloMinutos,vecesRepetir,user) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'eliminarHablaFacil' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function eliminarHablaFacil(hablaFacil:valueObjects.HablaFacil) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("eliminarHablaFacil");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(hablaFacil) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'agregarAccidente' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function agregarAccidente(accidente:valueObjects.Accidente) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("agregarAccidente");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(accidente) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'modificarHablaFacil' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function modificarHablaFacil(hablaFacil:valueObjects.HablaFacil) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("modificarHablaFacil");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(hablaFacil) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'modificarAccidente' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function modificarAccidente(accidente:valueObjects.Accidente) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("modificarAccidente");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(accidente) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'agregarHablaFacil' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function agregarHablaFacil(hablaFacil:valueObjects.HablaFacil) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("agregarHablaFacil");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(hablaFacil) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'eliminarRolCapacitacion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function eliminarRolCapacitacion(rolCapacitacion:valueObjects.RolCapacitacion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("eliminarRolCapacitacion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(rolCapacitacion) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'obtenerUsuario' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerUsuario(susuario:String, password:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerUsuario");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(susuario,password) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'obtenerHablaFacilReproductorPromedio' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerHablaFacilReproductorPromedio(tipoHablaFacil:int, fechaSeleccionada:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerHablaFacilReproductorPromedio");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(tipoHablaFacil,fechaSeleccionada) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'obtenerTacsaReproductor' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerTacsaReproductor(tipoTacsa:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerTacsaReproductor");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(tipoTacsa) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'modificarRolCapacitacion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function modificarRolCapacitacion(rolCapacitacion:valueObjects.RolCapacitacion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("modificarRolCapacitacion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(rolCapacitacion) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'obtenerRolCapacitacion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerRolCapacitacion(filtroRolCapacitacion:valueObjects.FiltroRolCapacitacion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerRolCapacitacion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(filtroRolCapacitacion) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'modificarParametro' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function modificarParametro(codigo1:int, valor1:String, codigo2:int, valor2:String, codigo3:int, valor3:String) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("modificarParametro");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(codigo1,valor1,codigo2,valor2,codigo3,valor3) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'modificarTacsa' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function modificarTacsa(tacsa:valueObjects.Tacsa) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("modificarTacsa");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(tacsa) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'eliminarAccidente' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function eliminarAccidente(accidente:valueObjects.Accidente) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("eliminarAccidente");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(accidente) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'obtenerHablaFacilReproductor' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function obtenerHablaFacilReproductor(tipoHablaFacil:int) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("obtenerHablaFacilReproductor");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(tipoHablaFacil) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'getMensajesValidos' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function getMensajesValidos() : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("getMensajesValidos");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send() ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'agregarTacsa' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function agregarTacsa(tacsa:valueObjects.Tacsa) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("agregarTacsa");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(tacsa) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarHablaFacil' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarHablaFacil(filtroHablaFacil:valueObjects.FiltroHablaFacil) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarHablaFacil");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(filtroHablaFacil) ;
        return _internal_token;
    }
     
    /**
      * This method is a generated wrapper used to call the 'listarRolCapacitacion' operation. It returns an mx.rpc.AsyncToken whose 
      * result property will be populated with the result of the operation when the server response is received. 
      * To use this result from MXML code, define a CallResponder component and assign its token property to this method's return value. 
      * You can then bind to CallResponder.lastResult or listen for the CallResponder.result or fault events.
      *
      * @see mx.rpc.AsyncToken
      * @see mx.rpc.CallResponder 
      *
      * @return an mx.rpc.AsyncToken whose result property will be populated with the result of the operation when the server response is received.
      */
    public function listarRolCapacitacion(filtroRolCapacitacion:valueObjects.FiltroRolCapacitacion) : mx.rpc.AsyncToken
    {
        model_internal::loadWSDLIfNecessary();
        var _internal_operation:mx.rpc.AbstractOperation = _serviceControl.getOperation("listarRolCapacitacion");
		var _internal_token:mx.rpc.AsyncToken = _internal_operation.send(filtroRolCapacitacion) ;
        return _internal_token;
    }
     
}

}
